Skip to main content

Overview

Repositories​

Repositories stores data during the library's operation and for setting the business logic of certain modules.

Interfaces for implementing repositories are located in the directory com.devexperts.dxcharts.lib.data.repo.

If you need to change logic of our default implementations of repositories, e.g. change default values, you need to create your own implementation of according repositories and pass them into DxChartsConfig.Repositories

Repository nameInterface pathDefault implementation pathDescription
Aggregations Repositorycom.devexperts.dxcharts.lib.data.repo.AgregationsRepositorycom.devexperts.dxcharts.lib.data.repo.default_repos.LocalStorageDefaultAggregationsRepositoryRepository for storing information about created and selected aggregations
Colors Repositorycom.devexperts.dxcharts.lib.data.repo.ColorsRepositorycom.devexperts.dxcharts.lib.data.repo.default_repos.LocalStorageDefaultColorsRepositoryRepository for storing color palette for indicators, settings, and drawings (except for the Highlighter type of drawings)
Highlighter Colors Repositorycom.devexperts.dxcharts.lib.data.repo.ColorsRepositorycom.devexperts.dxcharts.lib.data.repo.default_repos.LocalStorageDefaultHighlighterColorsRepositoryRepository for storing color palette for the Highlighter drawing
Drawings Repositorycom.devexperts.dxcharts.lib.data.repo.DrawingsRepositorycom.devexperts.dxcharts.lib.data.repo.default_repos.LocalStorageDefaultDrawingsRepositoryRepository for storing drawings system data:

Contains 4 child interfaces that handle data about:
1) IInitial press of "Magnet" and "Brush" buttons on the drawing toolbar - a hint should be shown on the first press, and it also stores whether the hint was shown after setting a text drawing.
2) Selected line thickness for drawings.
3) Selected drawings from the general list displayed in the corresponding toolbar.
4) Snapshots of drawings created on the chart.
Instrument Repositorycom.devexperts.dxcharts.lib.data.repo.InstrumentRepositorycom.devexperts.dxcharts.lib.data.repo.default_repos.LocalStorageDefaultInstrumentRepositoryRepository to store data about the selected instrument on the chart
Settings Repositorycom.devexperts.dxcharts.lib.data.repo.SettingsRepositorycom.devexperts.dxcharts.lib.data.repo.default_repos.LocalStorageDefaultSettingsRepositoryRepository for storing chart settings data
Studies Repositorycom.devexperts.dxcharts.lib.data.repo.StudiesRepositorycom.devexperts.dxcharts.lib.data.repo.default_repos.LocalStorageDefaultStudiesRepositoryRepository to store indicators settings data
Studies Templates Repositorycom.devexperts.dxcharts.lib.data.repo.StudiesTemplatesRepositorycom.devexperts.dxcharts.lib.data.repo.default_repos.LocalStorageDefaultStudiesTemplatesRepositoryRepository to store data about user-created templates of indicators.
Timeframe Presets Repositorycom.devexperts.dxcharts.lib.data.repo.TimeframeTemplatesRepositorycom.devexperts.dxcharts.lib.data.repo.default_repos.LocalStorageDefaultTimeframePresetsRepositoryRepository to store data about timeframe presets.

By default, data is not stored on the device - all data is cleared upon application reload. To prevent this from happening, the library user needs to implement the necessary repositories or you can use library implementation of repositories from serializable_storage_repos package. They have methods serialize() and deserialize(data: String) to save and load data from your app. serialize() method is called everytime when repository have some changes in its state and it save its state into shared preferences. According to that you also need to pass context as a parameter into serializable storage.

All you need is to create objects of the necessary repositories and pass them to the library using the DxChartsConfig and use deserialize(data: String) method:

   private val studiesRepository by lazy {
       SerializableStorageDefaultStudiesRepository(application, StudiesLoader().load(assets))
  }
  private val aggregationsRepository by lazy {
      SerializableStorageDefaultAggregationsRepository(application)
  }
  private val colorsRepository by lazy {
      SerializableStorageDefaultColorsRepository(application)
  }
  private val drawingsLineWidthRepo by lazy {
      SerializableStorageDefaultDrawingsLineWidthRepo(application)
  }
  private val drawingsSnapshotsRepo by lazy {
      SerializableStorageDefaultDrawingsSnapshotsRepo(application)
  }
  private val drawingsFirstClickRepo by lazy {
      SerializableStorageDefaultFirstClickRepo(application)
  }
  private val drawingsTypesRepo by lazy {
      SerializableStorageDefaultDrawingsTypesRepo(application)
  }
  private val highlighterColorsRepository by lazy {
      SerializableStorageDefaultHighlighterColorsRepository(application)
  }
  private val instrumentRepository by lazy {
      SerializableStorageDefaultInstrumentRepository(application)
  }
  private val timeframePresetsRepository by lazy {
      SerializableStorageDefaultTimeframePresetsRepository(application)
  }
  private val settingsRepository by lazy {
      SerializableStorageDefaultSettingsRepository(application)
  }
  private val studiesTemplatesRepository by lazy {
      SerializableStorageDefaultStudiesTemplatesRepository(application)
  }
  override fun onCreate(savedInstanceState: Bundle?) {
      super.onCreate(savedInstanceState)
      deserializeRepositories()
      //...
      setContent {
          DxChartsTheme {
              Surface(
                  modifier = Modifier.fillMaxSize(),
                  color = DxChartsTheme.colors.mainChartBg
              ) {
                  DxChartsScreen(
                      DxChartsConfig(
                          repositories = DxChartsConfig.Repositories(
                              studiesRepository = studiesRepository,
                              aggregationsRepository = aggregationsRepository,
                              colorsRepository = colorsRepository,
                              drawingsLineWidthRepo = drawingsLineWidthRepo,
                              drawingsSnapshotsRepo = drawingsSnapshotsRepo,
                              drawingsFirstClickRepo = drawingsFirstClickRepo,
                              drawingsTypesRepo = drawingsTypesRepo,
                              highlighterColorsRepository = highlighterColorsRepository,
                              instrumentRepository = instrumentRepository,
                              timeframePresetsRepository = timeframePresetsRepository,
                              settingsRepository = settingsRepository,
                              studiesTemplatesRepository = studiesTemplatesRepository
                          ),
                          //...
              }
          }
      }
  }
  private fun deserializeRepositories() {
      val prefs = application.getSharedPreferences("dxcharts_demo_app", MODE_PRIVATE)
      val aggregations = prefs.getString("aggregations_repo", null)
      val colors = prefs.getString("colors_repo", null)
      val drawingsLine = prefs.getString("drawings_line_repo", null)
      val drawingsSnapshots = prefs.getString("drawings_snapshots_repo", null)
      val drawingsTypes = prefs.getString("drawings_types_repo", null)
      val drawingsFirstClick = prefs.getString("drawings_first_click_repo", null)
      val highlighter = prefs.getString("highlighter_repo", null)
      val instrument = prefs.getString("instrument_repo", null)
      val settings = prefs.getString("settings_repo", null)
      val studies = prefs.getString("studies_repo", null)
      val studiesTemplates = prefs.getString("studies_templates_repo", null)
      val timeframePresets = prefs.getString("timeframe_presets_repo", null)
      aggregations?.let { aggregationsRepository.deserialize(it) }
      colors?.let { colorsRepository.deserialize(it) }
      drawingsLine?.let { drawingsLineWidthRepo.deserialize(it) }
      drawingsSnapshots?.let { drawingsSnapshotsRepo.deserialize(it) }
      drawingsTypes?.let { drawingsTypesRepo.deserialize(it) }
      drawingsFirstClick?.let { drawingsFirstClickRepo.deserialize(it) }
      highlighter?.let { highlighterColorsRepository.deserialize(it) }
      instrument?.let { instrumentRepository.deserialize(it) }
      settings?.let { settingsRepository.deserialize(it) }
      studies?.let { studiesRepository?.deserialize(it) }
      studiesTemplates?.let { studiesTemplatesRepository.deserialize(it) }
      timeframePresets?.let { timeframePresetsRepository.deserialize(it) }
  }